home *** CD-ROM | disk | FTP | other *** search
/ Shareware Super Platinum 8 / Shareware Super Platinum 8.iso / mac / WIN_PRO / DS-1.ZIP;1 / RTT.ZIP / RTTNODE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-10  |  4.8 KB  |  231 lines
  1. #include "rtt.h"
  2.  
  3. static struct node *node_free = NULL;
  4.  
  5. /*
  6.  * node0 - create a syntax tree leaf node.
  7.  */
  8. struct node *node0(id, tok)
  9. int id;
  10. struct token *tok;
  11.    {
  12.    struct node *n;
  13.    int i;
  14.  
  15.    if ((n = node_free) == NULL)
  16.       n = NewStruct(node);
  17.    else
  18.       node_free = node_free->u[0].child;
  19.  
  20.    n->nd_id = id;
  21.    n->tok = tok;
  22.    for (i = 0; i < NChildren; ++i)
  23.       n->u[i].child = NULL;
  24.    return n;
  25.    }
  26.  
  27. /*
  28.  * node1 - create a syntax tree node with one child.
  29.  */
  30. struct node *node1(id, tok, n1)
  31. int id;
  32. struct token *tok;
  33. struct node *n1;
  34.    {
  35.    struct node *n;
  36.    int i;
  37.  
  38.    if ((n = node_free) == NULL)
  39.       n = NewStruct(node);
  40.    else
  41.       node_free = node_free->u[0].child;
  42.  
  43.    n->nd_id = id;
  44.    n->tok = tok;
  45.    n->u[0].child = n1;
  46.    for (i = 1; i < NChildren; ++i)
  47.       n->u[i].child = NULL;
  48.    return n;
  49.    }
  50.  
  51. /*
  52.  * node2 - create a syntax tree node with two children.
  53.  */
  54. struct node *node2(id, tok, n1, n2)
  55. int id;
  56. struct token *tok;
  57. struct node *n1;
  58. struct node *n2;
  59.    {
  60.    struct node *n;
  61.    int i;
  62.  
  63.    if ((n = node_free) == NULL)
  64.        n = NewStruct(node);
  65.    else
  66.       node_free = node_free->u[0].child;
  67.  
  68.    n->nd_id = id;
  69.    n->tok = tok;
  70.    n->u[0].child = n1;
  71.    n->u[1].child = n2;
  72.    for (i = 2; i < NChildren; ++i)
  73.       n->u[i].child = NULL;
  74.    return n;
  75.    }
  76.  
  77. /*
  78.  * node3 - create a syntax tree node with three children.
  79.  */
  80. struct node *node3(id, tok, n1, n2, n3)
  81. int id;
  82. struct token *tok;
  83. struct node *n1;
  84. struct node *n2;
  85. struct node *n3;
  86.    {
  87.    struct node *n;
  88.    int i;
  89.  
  90.    if ((n = node_free) == NULL)
  91.       n = NewStruct(node);
  92.    else
  93.       node_free = node_free->u[0].child;
  94.  
  95.    n->nd_id = id;
  96.    n->tok = tok;
  97.    n->u[0].child = n1;
  98.    n->u[1].child = n2;
  99.    n->u[2].child = n3;
  100.    for (i = 3; i < NChildren; ++i)
  101.       n->u[i].child = NULL;
  102.    return n;
  103.    }
  104.  
  105. /*
  106.  * node4 - create a syntax tree node with four children.
  107.  */
  108. struct node *node4(id, tok, n1, n2, n3, n4)
  109. int id;
  110. struct token *tok;
  111. struct node *n1;
  112. struct node *n2;
  113. struct node *n3;
  114. struct node *n4;
  115.    {
  116.    struct node *n;
  117.    int i;
  118.  
  119.    if ((n = node_free) == NULL)
  120.       n = NewStruct(node);
  121.    else
  122.       node_free = node_free->u[0].child;
  123.  
  124.    n->nd_id = id;
  125.    n->tok = tok;
  126.    n->u[0].child = n1;
  127.    n->u[1].child = n2;
  128.    n->u[2].child = n3;
  129.    n->u[3].child = n4;
  130.    for (i = 4; i < NChildren; ++i)
  131.       n->u[i].child = NULL;
  132.    return n;
  133.    }
  134.  
  135. /*
  136.  * node4 - create a syntax tree node for a variable. If the identifier
  137.  *  is in the symbol table, create a node that references the entry,
  138.  *  otherwise create a simple leaf node.
  139.  */
  140. struct node *var_node(tok)
  141. struct token *tok;
  142.    {
  143.    struct sym_entry *sym;
  144.    struct node *n;
  145.  
  146.    sym = sym_lkup(tok->image);
  147.    if (sym != NULL) { 
  148.       if ((n = node_free) == NULL)
  149.          n = NewStruct(node);
  150.       else
  151.          node_free = node_free->u[0].child;
  152.       n->nd_id = SymNd;
  153.       n->tok = tok;
  154.       n->u[0].sym = sym;
  155.       ++sym->ref_cnt;
  156.       /*
  157.        * If this is the result location of an operation, note that it
  158.        *  is explicitly referenced.
  159.        */
  160.       if (sym->id_type == RsltLoc)
  161.          sym->u.referenced = 1;
  162.       return n;
  163.       }
  164.    else
  165.       return node0(PrimryNd, tok);
  166.    }
  167.  
  168. /*
  169.  * comp_nd - create a node for a compound statement.
  170.  */
  171. struct node *comp_nd(tok, dcls, stmts)
  172. struct token *tok;
  173. struct node *dcls;
  174. struct node *stmts;
  175.    {
  176.    struct node *n;
  177.  
  178.    if ((n = node_free) == NULL)
  179.       n = NewStruct(node);
  180.    else
  181.       node_free = node_free->u[0].child;
  182.    n->nd_id = CompNd;
  183.    n->tok = tok;
  184.    n->u[0].child = dcls;
  185.    n->u[1].sym = dcl_stk->tended; /* tended declarations are not in dcls */
  186.    n->u[2].child = stmts;
  187.    return n;
  188.    }
  189.  
  190. /*
  191.  * free_tree - free storage for a syntax tree.
  192.  */
  193. novalue free_tree(n)
  194. struct node *n;
  195.    {
  196.    int i;
  197.    struct sym_entry *sym, *sym1;
  198.  
  199.    if (n == NULL)
  200.       return;
  201.  
  202.    /*
  203.     * Free any subtrees and other referenced storage.
  204.     */
  205.    switch (n->nd_id) {
  206.       case SymNd:
  207.          free_sym(n->u[0].sym); /* Indicate one less reference to symbol */
  208.          break;
  209.       case CompNd:
  210.          /*
  211.           * Compound node. Free ordinary declarations, tended declarations,
  212.           *  and executable code.
  213.           */
  214.          free_tree(n->u[0].child);
  215.          sym = n->u[1].sym;
  216.          while (sym != NULL) {
  217.             sym1 = sym;
  218.             sym = sym->u.tnd_var.next;
  219.             free_sym(sym1);
  220.             }
  221.          free_tree(n->u[2].child);
  222.          break;
  223.       default:
  224.          for (i = 0; i < NChildren; ++i)
  225.             free_tree(n->u[i].child);
  226.          }
  227.    free_t(n->tok);             /* free token */
  228.    n->u[0].child = node_free;  /* put node on free list */
  229.    node_free = n;
  230.    }
  231.